#!/usr/bin/env python
# -*- coding: utf-8 -*-

"""
配置管理器模块
负责管理应用程序的配置
"""

import os
import json
import logging
from typing import Dict, Any

# 配置日志
logger = logging.getLogger(__name__)

class ConfigManager:
    """配置管理器类"""
    
    def __init__(self, config_path: str = None):
        """
        初始化配置管理器
        
        Args:
            config_path (str, optional): 配置文件路径，默认为当前目录下的config.json
        """
        # 配置文件路径
        self.config_path = config_path or os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), 'config.json')
        
        # 默认配置
        self.default_config = {
            '语言': 'zh',  # 默认语言
            '主题': 'light',  # 默认主题
            '摘要': {
                '算法': 'extractive',  # extractive 或 abstractive
                '默认比例': 0.3,  # 摘要长度占原文的比例
                '关键词数量': 10  # 提取的关键词数量
            },
            '文档': {
                '支持格式': ['txt', 'pdf', 'docx', 'md', 'html'],
                '最大大小': 10485760  # 10MB
            },
            '历史': {
                '自动保存': True,  # 是否自动保存摘要
                '最大数量': 100  # 最大历史记录数量
            },
            'web': {
                '主机': '127.0.0.1',
                '端口': 8080
            }
        }
        
        # 加载配置
        self.config = self.load_config()
        
        logger.info("配置管理器初始化完成")
    
    def load_config(self) -> Dict[str, Any]:
        """
        加载配置
        
        Returns:
            dict: 配置字典
        """
        try:
            # 如果配置文件存在，从文件加载配置
            if os.path.exists(self.config_path):
                with open(self.config_path, 'r', encoding='utf-8') as f:
                    config = json.load(f)
                
                # 合并默认配置和加载的配置
                merged_config = self.default_config.copy()
                self._deep_update(merged_config, config)
                
                logger.info(f"从 {self.config_path} 加载配置成功")
                return merged_config
            else:
                # 如果配置文件不存在，使用默认配置并保存
                self.save_config(self.default_config)
                logger.info(f"配置文件不存在，创建默认配置：{self.config_path}")
                return self.default_config
        
        except Exception as e:
            logger.error(f"加载配置失败: {str(e)}")
            return self.default_config
    
    def save_config(self, config: Dict[str, Any] = None) -> bool:
        """
        保存配置
        
        Args:
            config (dict, optional): 要保存的配置，默认为当前配置
            
        Returns:
            bool: 是否保存成功
        """
        try:
            # 如果未提供配置，使用当前配置
            if config is None:
                config = self.config
            
            # 确保配置目录存在
            os.makedirs(os.path.dirname(self.config_path), exist_ok=True)
            
            # 保存配置到文件
            with open(self.config_path, 'w', encoding='utf-8') as f:
                json.dump(config, f, ensure_ascii=False, indent=4)
            
            logger.info(f"配置保存成功：{self.config_path}")
            return True
        
        except Exception as e:
            logger.error(f"保存配置失败: {str(e)}")
            return False
    
    def get_config(self) -> Dict[str, Any]:
        """
        获取当前配置
        
        Returns:
            dict: 当前配置
        """
        return self.config
    
    def update_config(self, new_config: Dict[str, Any]) -> bool:
        """
        更新配置
        
        Args:
            new_config (dict): 新的配置
            
        Returns:
            bool: 是否更新成功
        """
        try:
            # 深度更新配置
            self._deep_update(self.config, new_config)
            
            # 保存更新后的配置
            return self.save_config()
        
        except Exception as e:
            logger.error(f"更新配置失败: {str(e)}")
            return False
    
    def reset_config(self) -> bool:
        """
        重置配置为默认值
        
        Returns:
            bool: 是否重置成功
        """
        try:
            # 使用默认配置
            self.config = self.default_config.copy()
            
            # 保存默认配置
            return self.save_config()
        
        except Exception as e:
            logger.error(f"重置配置失败: {str(e)}")
            return False
    
    def _deep_update(self, d: Dict[str, Any], u: Dict[str, Any]):
        """
        深度更新字典
        
        Args:
            d (dict): 目标字典
            u (dict): 源字典
        """
        for k, v in u.items():
            if isinstance(v, dict) and k in d and isinstance(d[k], dict):
                self._deep_update(d[k], v)
            else:
                d[k] = v